import request from "../utils/request";

/**
 * 用户登录-zh--->success
 * @param userName 用户名
 * @param password 密码，密文
 * @returns 登录结果
 */
export let userLogin = (userName: string, password: string) => {
    return request.post("/user/login", {
        'userName': userName,
        'password': password
    })
}

/**
 * 获取rsa加密后的aes秘钥-->success
 * @returns 获取加密后的aes秘钥，前段通过rsa私钥解密，后加密密码
 */
export let getEncryptedAESKey = () => {
    return request.get("/user/requestAes")
}

/**
 * 请求系统中存在的所有tag标签-zh--->success
 * @returns 返回系统中的所有标签的数据
 */
export let getAllTags = () => {
    return request.get("/Tag/findAllTag")
}

/**
 * 获取系统中不同时间段的点赞排行榜-zh-->success
 * @param status 时间范围 0:一周内，1：一个月内
 * @param pageNo 需要请求的页码
 * @param pageSize 每页展示的文章数量
 * @returns 时间范围内系统点赞排行榜数据
 */
export let getLikeRankData = (status: number, pageNo: number = 1, pageSize: number = 5) => {
    return request.get("/knowledge/selectHotKnowledgeByLike", {
        params: {
            pageNo: pageNo,
            pageSize: pageSize,
            status: status
        }
    })
}
/**
 * 获取选择时间范围内系统的热度排行榜数据-zh-->success
 *@param status 时间范围 0:一周内，1：一个月内
 * @param pageNo 需要请求的页码
 * @param pageSize 每页展示的文章数量
 * @returns 时间范围内系统的热度排行榜数据
 */
export let getHotRankData = (status: number, pageNo: number = 1, pageSize: number = 5) => {
    return request.get("/knowledge/selectHotKnowledgeByView", {
        params: {
            pageNo: pageNo,
            pageSize: pageSize,
            status: status
        }
    })
}


/**
 * 获取系统知识推荐展示的文章数据-zh-->success
 * @param pageSize 每页展示的文章数量
 * @param pageNo 需要检索的页码
 * @returns 当前需要检索的页码的文章数据
 */
export let getArticleList = (pageSize: Number = 10, pageNo: Number = 1) => {
    return request.get("/knowledge/recommendByTags", {
        params: {
            pageSize: pageSize,
            pageNo: pageNo
        }
    })
}


/** zh-->success
 * 高级检索检索和普通检索采用相同的接口，只是普通检索只传keyword,没有的数据传空
 * @param advancedForm 高级检索的表单数据
 * @returns 检索结果的文章列表
 */
export let advancedSearchArticles = (advancedForm: {
    keyword: string,
    tagId?: number[],
    kind?: number[],
    createTime?: Date[] | null,
    authorName?: string,
    sortType: string,
    pageNo: number,
    pageSize: number
}) => {
    const data = advancedForm;
    // console.log(data);
    return request.post("/knowledge/advancedSearch", data)
}


/**
 * 获取数据上传的token-zh-->success
 * @returns 获取七牛云数据上传的token
 */
export let getQiNiuToken = () => {
    return request.get("/upload/token/get")
}

/**
 * 上传图片到七牛云-zh-->success
 * @param token 七牛云的token
 * @param file 上传的图片文件
 * @returns 上传的图片的反馈信息
 */
export let uploadFileToQiNiu = (token: string, file: any) => {
    // console.log(file);
    return request.post("/upload/toQiniu",
        file,
        {
            params: {
                token: token
            },
        })
}

/**
 * 将头像的地址写入到数据库中-zh-->success
 * @param avatarUrl 头像的地址
 */
export let uploadAvatarToDB = (avatarUrl: string) => {
    return request.get("/user/saveAvatar", {
        params:{
            avatar: avatarUrl
        }
    })
}

/**
 * 获取文章详细信息的接口-zh-->success
 * @param knowledgeId 当前文章的id
 * @returns 文章的详细信息
 */
export let getKnowledgeDetail = (knowledgeId: number) => {
    return request.get("/knowledge/knowledge_detail", {
        params: {
            knowledgeId: knowledgeId
        }
    })
}

/**
 * 获取用户的对某一文章的点赞状态-zh-->success
 * @param knowledgeId 浏览文章的id
 * @returns 当前用户对该文章的点赞状态
 */
export let getIsLike = (knowledgeId: number) => {
    return request.get("/knowledge/isLiked/"+knowledgeId)
}

/**
 * 获取用户对某一文章的收藏状态-zh--》success
 * @param knowledgeId 浏览文章的id
 * @returns 当前用户对文章的收藏状态
 */
export let getIsCollect = (knowledgeId: number) => {
    return request.get("/knowledge/isCollected/"+knowledgeId)
}


/**
 * 点赞或者取消点赞的接口-zh--》success
 * @param knowledgeId 浏览文章的id
 * @returns 点赞或者取消点赞的反馈信息，现在的点赞数
 */
export let addOrRemoveLike = (knowledgeId: number) => {
    return request.post(`/like/knowledge/${knowledgeId}`)
}

/**
 * 收藏或者取消收藏的接口-zh--》success
 * @param knowledgeId 浏览文章的id
 * @returns 点赞和取消点赞的反馈信息，现在的收藏
 */
export let addOrRemoveCollect = (knowledgeId: number) => {
    return request.post(`/collect/knowledge/${knowledgeId}`)
}

/**
 * 获取文章评论的接口-zh--》success
 * @param knowledgeId 当前文章的id
 * @returns 获取文章下面评论
 */
export let getComment = (knowledgeId: number) => {
    return request.get("/knowledge/comment", {
        params: {
            knowledgeId: knowledgeId
        }
    })
}

/**
 * 在文章下面添加评论，添加的是一级评论-zh--》success
 * @param knowledgeId 浏览文章的id
 * @param comment 评论的内容
 * @returns 添加评论的反馈状态
 */
export let addComment = (knowledgeId: number, comment: string) => {
    return request.get("/knowledge/addComment", {
        params: {
            knowledgeId: knowledgeId,
            comment: comment
        }
    })
}

/**
 * 添加二级评论的接口-zh--》success
 * @param commentId 回复的评论的id
 * @param reply 回复的内容
 * @param replyUserId 回复人的id
 * @returns 
 */
export let addSecondComment = (commentId: number, reply: string, replyUserId: number) => {
    return request.get("/reply/addReply", {
        params: {
            commentId: commentId,
            reply: reply,
            replyUserId: replyUserId
        }
    })
}


/**
 * 删除评论的接口-zh--》success
 * @param commentId 评论的id
 * @param commentType 评论的类型，0：一级评论，1：二级评论
 * @returns 返回删除评论的反馈信息
 */
export let deleteComment = (commentId: number, commentType: number) => {
    return request.get("/knowledge/deleteComment", {
        params: {
            id: commentId,
            type: commentType
        }
    })
}

/**
 * 将文章提交管理员审核-zh-->success
 * @param addKnowledgeData 添加的文章的所有信息
 * @returns 文章提交审核的反馈信息
*/
export let addKnowledge = (addKnowledgeData: {
    authorId: number,
    content: string,
    kind: number | string,
    knowledgeId?: number | null,
    status: number,
    tagId: number[],
    title: string,
}) => {
    return request.post("/knowledge/addKnowledge", addKnowledgeData)
}

/**
 * 删除文章对应id的数据库内容和七牛云中的图片等资源-zh-->success
 * 存在不同的删除模式，如果是已发布的文章在数据库中是逻辑删除，如果是草稿箱、待审核、被驳回的文章
 * 是物理删除
 * @param knowledgeId 文章id
 * @returns 删除文章的反馈信息
 */
export let deleteKnowledge = (knowledgeId: number) => {
    return request.get("/user/deleteMyKnowledge", {
        params: {
            knowledgeId: knowledgeId
        }
    })
}

/**
 * 获取个人中心我收藏的文章的数据-zh-->success
 * @param pageNo 请求页码
 * @param pageSize 每页数据量
 * @returns 我收藏的文章信息
 */
export let getMyCollect = (pageNum: number = 1, pageSize: number = 10) => {    
    return request.get("/user/myCollect", {
        params: {
            pageNum: pageNum,
            pageSize: pageSize
        }
    })
}

/**
 *  获取我的全部评论--》success
 * @param pageNo 当前的页码
 * @param pageSize 当前页的大小
 * @returns 返回用户的所有评论
 */
export let getAllMyComment = (pageNum: number = 1, pageSize: number = 10) => {
    return request.get("/user/myComment", {
        params: {
            pageNum: pageNum,
            pageSize: pageSize
        }
    })
}

/**
 * 获取我的点赞的文章的数据-zh-->success
 * @param pageNo 请求的页码
 * @param pageSize 每页的数据量
 * @returns 我点赞的文章的信息
 */
export let getMyLike = (pageNum: number = 1, pageSize: number = 10) => {
    return request.get("/user/myLike", {
        params: {
            pageNum: pageNum,
            pageSize: pageSize
        }
    })
}

/**-->还未查看文档对接。
 * 定时保存文章的接口-zh
 * @returns 定时保存的时间，以秒/毫秒为单位
 */
export let saveTime = () => {
    return request.get("/api/saveTime")
}



/**
 * 更新用户的个人信息-zh-->success
 * @param userInfo 用户的个人信息
 * @returns 更新用户信息的反馈信息
 */
export let updateUserInfo = (userInfo: {
    avatar?: string,
    email?: string,
    introduction?: string,
    nickname?: string,
    nickName?: string,
    qq?: string,
    sex?: string,
    showAge?: string,
    showEmail?: string,
    showQQ?: string,
    showSex?: string,
    showWeChat?: string,
    tags?: number[],
    weChat?: string,
}) => {
    return request.post("/user/editMyInfo", userInfo)
}

/**
 * 请求发送验证码的接口-zh-->TODO:还没有测试
 * @param email 用户新的邮箱
 * @returns 验证码发送的反馈信息
 */
export let sendVerificationCode = (email: string) => {
    return request.post("/api/sendVerificationCode", {
        email: email
    })
}

/**
 * 发送修改邮箱的请求-zh-->success
 * @param email 用户的新邮箱
 * @param code 用户的验证码
 * @returns 修改邮箱的反馈信息
 */
export let changeUserEmail = (email: string, code: string) => {
    return request.post("/user/myEmailBinding", {
        email: email,
        code: code
    })
}

/**
 * 用户发送请求修改密码的接口-zh-->success
 * @param oldPassword 老密码
 * @param newPassword 新密码
 * @returns 修改密码的反馈信息
 */
export let changeUserPassword = (oldPassword: string, newPassword: string) => {
    return request.post("/user/changePassword", {
        newPassword: newPassword,
        oldPassword: oldPassword
    })
}


/**
 * 用户进行账号注销的接口-zh-->success
 * @returns 返回注销的反馈信息
 */
export let cancelUserAccount = () => {
    return request.get("/user/accountCancel")
}


/**
 * 获取不同状态下的文章数据接口-zh-->success
 * @param status 需要查询文章的状态，0：草稿箱，1：待审核，2：已发布，3：被驳回，4：全部
 * @param pageNum 当前页码
 * @param pageSize 每页展示的文章数量
 * @returns 文章的基本信息数据
 */
export let getDifferentStateKnowledge = (status: number, pageSize: number, pageNum: number = 1,) => {
    return request.get("/user/myKnowledge", {
        params: {
            status: status,
            pageSize: pageSize,
            pageNum: pageNum
        }
    })
}



/**
 * 获取不同时间段的文章数据--》success
 * @param year 需要获取的数据的年份
 * @returns 该年份下的所有文章数据
 */
export let getEveryYearPublish = (year: string) => {
    return request.get("/user/myEveryDayPublished", {
        params: {
            year: year
        }
    })
}

/**
 * 获取一定时间年内用户的标签数据分析--》success
 * @param startTime 统计数据的开始时间
 * @param endTime 统计数据的结束时间
 * @returns 数据的统计结果
 */
export let getTagAnalysis = (startTime: string, endTime: string) => {
    return request.get("/user/myTagAnalyse", {
        params: {
            startTime: startTime,
            endTime: endTime
        }
    })
}

/**
 * 获取用户的全部信息-->success
 * @returns 获取用户的详细信息
 */
export let getWholeUserInfo = () => {
    return request.get("/user/myWholeUserInfo")
}



//审核人员查找特定时间状态的知识——搜索按钮---对接完成
export let FindStatus = (rParams: object, pageNum: number, pageSize: number) => {
    return request.post("/knowledgeAuditor/auditorSearch",
        rParams
        , {
            params: {
                'pageNum': pageNum,
                'pageSize': pageSize
            }
        },
    )
}//使用

//审核人员点击审核按钮具体审核具体知识---对接完成
export let AuditKnowledge = (id: number) => {
    return request.get("/knowledgeAuditor/getAwatingKnowledgeDetail", {
        params: {
            knowledgeId: id
        }
    })
}//使用


//分页请求数据---已对接
export let FindKonwledgesByPage = (page: number, size: number, id: number) => {
    return request.get("/knowledgeAuditor/getAwatingKnowledge", {
        params: {
            pageNum: page,
            pageSize: size,
            userId: id
        }
    })
}//使用


//审核通过---对接完毕
export let AuditPass = (konwId: number, id: number) => {
    return request.get("/knowledgeAuditor/knowledgePass", {
        params: {
            knowledgeId: konwId,
            userId: id,
        }
    })
}//使用

//审核人员驳回知识---对接完成
export let overrule = (konwId: number, id: Number, suggest: string) => {
    return request.get("/knowledgeAuditor/knowledgeReject", {
        params: {
            knowledgeId: konwId,
            userId: id,
            rejectReason: suggest
        }
    })
}//使用

//管理人员查看所有标签
export let FindAdminTag = () => {
    return request.get("/api/FindAdminTag")
}

//管理人员分页查询标签---对接完成
export let FindAdminTagByPage = (page: number, size: number) => {
    return request.get("/Tag/getTagByPage", {
        params: {
            Page: page,
            Size: size
        }
    })
}//使用

//管理人员查看所有人员信息
export let FindAdminUser = () => {
    return request.get("/api/FindAdminUser")
}

//管理人员分页查询人员信息----对接完毕
export let FindAdminUserByPage = (page: number, size: number) => {
    return request.get("/admin/pageUserInfo", {
        params: {
            Page: page,
            Size: size
        }
    })
}//使用

//管理人员搜索栏用---对接完毕
export let FindAdminUserBySearch = (username: string, pageNum: number, pageSize: number) => {
    return request.get("/admin/findUser", {
        params: {
            userName: username,
            pageNum: pageNum,
            pageSize: pageSize
        }
    })
}//使用

//编辑标签
export let EditTag = (oldId: number, newTag: string) => {
    return request.get("/Tag/updateTag", {
    params:{
    id: oldId,
    name: newTag
}
    })
}//使用


//删除标签
export let DeleteTag = (id: number) => {
    return request.get("/Tag/delTagById", {
       params:{
        id: id
       }
    })
}//使用

//添加用户---对接完成
export let AddUser = (username: string, role: number, password: string) => {
    return request.get("/admin/addNewUser", {
        params: {
            userName: username,
            roleId: role,
            password: password
        }
    })
}//使用

//编辑用户---对接完成
export let EditUser = (username: string, role: number, oldId: number) => {
    return request.get("/admin/changeUserInfo", {
        params: {
            userName: username,
            roleId: role,
            userId: oldId
        }
    })
}//使用

//删除用户---对接完成
export let DeleteUser = (id: number) => {
    return request.get("/admin/deleteUser", {
        params: {
            userId: id
        }
    })
}

//检索权重---对接完成
export let SearchWeight = (title: number, label: number, type: number, time: number, author: number) => {
    return request.get("/admin/setWeight", {
        params: {
            Title: title,
            Label: label,
            Type: type,
            Time: time,
            Author: author
        }
    })
}//使用

//自动保存时间修改
export let autoSaveTime = (time: number) => {
    return request.get("/api/autoSaveTime", {
        params: {
            Time: time
        }
    })
}//使用



//忘记密码重置密码---修改完未对接
export let ResetPassword = (mailName: string, code: string, newPassword: string) => {
    return request.post("/user/findPassword", {
        mailName: mailName,
        code: code,
        newPassword: newPassword
    })
}

//添加标签---对接完成
export let AddTag = (name: string) => {
    let Name = name
    return request.get("/Tag/addTag", {
        params: {
            name: Name
        }
    })
}//使用

//发送邮箱---对接完成
export let SendMail = (mailName: string) => {
    return request.get("/user/send/code", {
        params: {
         mailName:mailName
        }
    })
}